home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / lpn_demo.c < prev    next >
Text File  |  1993-08-23  |  11KB  |  475 lines
  1. /* lpn_demo.c */
  2. /* LOGICON PROJECTION NETWORK (TM) Circle/half-plane demo */
  3. /************************************************************************
  4.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  5.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  6.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  7.  *                                                                      *
  8.  * All rights reserved.  No part of this program may be reproduced,     *
  9.  * stored in a retrieval system, or transmitted, in any form or by any  *
  10.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  11.  * without the prior written permission of the copyright owner,         *
  12.  * NeuralWare, Inc.                                                     *
  13.  *                                                                      *
  14.  *                          PROPRIETARY NOTICE                          *
  15.  *                                                                      *
  16.  * This document is the property of NeuralWare, Inc. and contains       *
  17.  * trade-secrets and other proprietary information.  The information    *
  18.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  19.  * published, reproduced, copied, disclosed, used, or reverse           *
  20.  * engineered without the express written consent of a duly authorized  *
  21.  * representative of NeuralWare.                                        *
  22.  ************************************************************************
  23.  */
  24.  
  25. #define UIO_SERVER             1
  26. #define SERVER_EMULATOR_FILE   1
  27. #define SKIP_COMPAT_DATA       1
  28. #include "userutl.h"
  29. #include "uio_strc.h"
  30. #include "uio_tran.h"
  31. #include "uio_reqs.pro"
  32. #include "uio_cmds.pro"
  33.  
  34. #include <math.h>
  35.  
  36. #ifdef MAC
  37. #include "macuio.redef"
  38. #endif
  39.  
  40. int W_Wid  = {400};  /* basic defining parameters */
  41. int W_Ht   = {200};  /* height of graph */
  42. int count = 0;
  43. int good_count = 0;
  44. float      xin, yin, desval;
  45. TEXT  sbuf[200];
  46. int   circ_color;
  47. int   back_color;
  48. int   on_color;
  49. int   off_color;
  50.  
  51. int   savebestf;    /* Save best flag */
  52. float clssrate;     /* Classification rate */
  53.  
  54. #define W0 1
  55. #define W1 2
  56. #define UPDT_INTERVAL 100
  57.  
  58. #define BIAS_LYRX (-1)
  59. #define PROJ_LYRX 1
  60. #define PROTO_LYRX 2
  61.  
  62. NINT UIO_Init(file)
  63. TEXT *file;
  64. {
  65.   NINT       ypos;
  66.   NINT       ret_val = UIO_OK;
  67.   NINT       xsize, ysize, ncolor, chrx, chry; /* graphics parameters */
  68.  
  69.   savebestf = 0;
  70.  
  71.   /* Get screen parameters */
  72.   ug_gparms( &xsize, &ysize, &ncolor, &chrx, &chry);
  73.   
  74.   if ( ncolor < 8 ) {
  75.     circ_color = 1;
  76.     back_color = 0;
  77.     on_color   = 1;
  78.     off_color  = 0;
  79.   } else {
  80.     circ_color = 1;
  81.     back_color = 0;
  82.     on_color   = 6;
  83.     off_color  = 5;
  84.   }
  85.  
  86.   ypos = ysize - W_Ht - 100;
  87.   if (ypos < 75)
  88.      ypos = 75;
  89.   if (ypos > 300)
  90.      ypos = 300;
  91.  
  92.   /* Set up windows */
  93.   ug_window(W0, back_color, 20, ypos+25, 20+W_Wid, ypos+25+W_Ht);
  94.   ug_window(W1, back_color, 20, ypos, 20+W_Wid, ypos+24);
  95.  
  96.   return(ret_val);
  97. }
  98.  
  99.  
  100. NINT UIO_Term(process)
  101. NINT process;
  102. {
  103.   NINT ret_val = UIO_OK;
  104.  
  105.   return(ret_val);
  106. }
  107.  
  108. NINT UIO_Attention()
  109. {
  110.   NINT ret_val = UIO_OK;
  111.  
  112.   return(ret_val);
  113. }
  114.  
  115.  
  116. NINT UIO_Learn_Start()
  117. {
  118.   NINT ret_val = UIO_OK;
  119.  
  120.   /* Set up learn file */
  121.   ug_fileio("crcpltrn", 0, 1, 1, 1);
  122.  
  123.   count = 0;
  124.  
  125.   return(ret_val);
  126. }
  127.  
  128. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  129. NINT  LayN;
  130. NINT  nPEs;
  131. SREAL *Datap;
  132. {
  133.   NINT ret_val = UIO_OK;
  134.  
  135.   return(ret_val);
  136. }
  137.  
  138. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  139. NINT  LayN;
  140. NINT  nPEs;
  141. SREAL *Datap;
  142. {
  143.   NINT ret_val = UIO_OK;
  144.  
  145.   return(ret_val);
  146. }
  147.  
  148.  
  149. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  150. NINT  LayN;
  151. NINT  nPEs;
  152. SREAL *Datap;
  153. {
  154.    ALYR  alyr;              /* layer info */
  155.    NINT  n_cn_vals;
  156.    SREAL cn_vals[10];       /* Connection values */
  157.    SREAL bias;              /* Bias */
  158.    SREAL thrsh, wr0, wr;    /* Projection work values */
  159.    SREAL Rad, Rado;         /* Projection radius and distance */
  160.    SREAL cntr_x, cntr_y;    /* Center of unprojected prototype */
  161.    SREAL prad;              /* Radius of unprojected prototype */
  162.    SREAL nrm;               /* norm of connections */
  163.    CTRIO_T ctrs[8];         /* Counters */    
  164.    NINT  wx,wy;             /* Work indices */
  165.    NINT  gcx,gcy,grad;      /* Graphical circle params */
  166.    NINT  ret_val = UIO_OK;
  167.  
  168.    count++;
  169.  
  170.    if (count !=1 && (count%UPDT_INTERVAL) != 0)
  171.       return(ret_val);
  172.  
  173.    ug_winclr(W0);
  174.    ug_winclr(W1);
  175.    ug_circle(W0,circ_color,0,
  176.              (NINT)(0.35*W_Wid), (NINT)(0.50*W_Ht), (NINT)(0.4*W_Ht),
  177.              circ_color==on_color?0:1);
  178.    if (circ_color==on_color)
  179.       ug_line(W0,circ_color,0,(NINT)(0.75*W_Wid),0,(NINT)(0.75*W_Wid),W_Ht,0);
  180.    else
  181.       ug_boxf(W0,circ_color,0,(NINT)(0.75*W_Wid),1,W_Wid,W_Ht);
  182.  
  183.    /* Read counters */
  184.    ug_ctrio(ctrs,0);
  185.  
  186.    sprintf(sbuf,"Logicon Projection Network (TM).  Lrn Cnt:%7ld",
  187.            ctrs[2]);
  188.    ug_puts(W1,on_color,0,6,4,sbuf,0);
  189.  
  190.    /* Get info from projection layer. */
  191.    ug_lyrio(&alyr, 0, PROJ_LYRX);
  192.  
  193.    Rad  = alyr.scale;
  194.    Rado = alyr.offst;
  195.  
  196.    /* Get info from prototype layer */
  197.    ug_lyrio(&alyr, 0, PROTO_LYRX);
  198.  
  199.    /* Now traverse the prototype layer  */
  200.    for (wx=0; wx<alyr.num_pes; wx++) {
  201.  
  202.       /* Get connections from projection layer; there should be 3 */
  203.       n_cn_vals = 3;  /* 3 pes in projection layer */
  204.       ug_cnio(PROTO_LYRX,wx,PROJ_LYRX,0,&n_cn_vals,0,0,cn_vals);
  205.       if (n_cn_vals != 3)
  206.          break;
  207.       n_cn_vals = 1;
  208.       ug_cnio(PROTO_LYRX,wx,BIAS_LYRX,0,&n_cn_vals,0,0,&bias);
  209.       if (n_cn_vals != 1)
  210.          break;
  211.  
  212.       /* If the prototypes are not getting projected back
  213.          to the hypersphere, we should project them back */
  214.       nrm=0.0;
  215.       /* Calculate radius of hyperwhere current weight sits on */
  216.       for (wy=0; wy<3; wy++)
  217.          nrm += cn_vals[wy]*cn_vals[wy];
  218.       if (fabs(nrm) < NRZRO)
  219.          break;
  220.       nrm = Rad/sqrt(nrm);
  221.       /* Scale the whole thing down, including threshold */
  222.       for (wy=0; wy<3; wy++)
  223.          cn_vals[wy] *= nrm;
  224.       bias *= nrm;
  225.  
  226.       thrsh = 0.0-bias;
  227.       wr0   = 0.0-cn_vals[2];
  228.  
  229.       wr = wr0+(thrsh/Rad);
  230.  
  231.       if (fabs(wr) > NRZRO) {
  232.          NINT on_sphere;
  233.  
  234.          wr = Rado/wr;
  235.  
  236.          cntr_x = wr*cn_vals[0];
  237.          cntr_y = wr*cn_vals[1];
  238.          prad = thrsh/(Rad*Rad);
  239.          prad = 1.0 - (prad*prad);
  240.  
  241.          if (prad > NRZRO) {
  242.             prad = wr*Rad*sqrt(prad);
  243.             on_sphere = 1;
  244.          } else
  245.             on_sphere = 0;
  246.  
  247.          /* Following assumes that data is between -1 and 1
  248.             for x, and between -0.5 and 0.5 for y */
  249.          gcx  = 0.5*(cntr_x+1.0)*W_Wid;
  250.          gcy  = (cntr_y+0.5)*W_Ht;
  251.  
  252.          if (on_sphere) {
  253.             if (prad < 0.0)
  254.                prad = 0.0-prad;
  255.             grad = prad*W_Ht;
  256.             ug_circle(W0,on_color,0,gcx,gcy,grad,0);
  257.          } else {
  258.             /* Prototype radius too large; draw cross-hair */
  259.             ug_line(W0,on_color,0,gcx-10,gcy,gcx+10,gcy,0);
  260.             ug_line(W0,on_color,0,gcx,gcy-10,gcx,gcy+10,0);
  261.          }
  262. #if 0 /* For debugging */
  263.          {
  264.             TEXT *sp;
  265.             
  266.             sprintf(sbuf,"thrs=%f,wr0=%f,wr=%f,cx=%f,cy=%f,rad=%f,nrm=%f",
  267.                     thrsh,wr0,wr,cntr_x,cntr_y,prad,nrm);
  268.             PutStr(sbuf);
  269.             sp=GetStr( );
  270.             if (*sp=='q' || *sp=='Q')
  271.                ret_val = UIO_EXIT;
  272.             PutStr("\n");
  273.          }
  274. #endif
  275.       }
  276.    }
  277.   
  278.    return(ret_val);
  279. }
  280.  
  281. NINT UIO_Learn_End()
  282. {
  283.   NINT ret_val = UIO_OK;
  284.  
  285.   return(ret_val);
  286. }
  287.  
  288. NINT UIO_Recall_Start()
  289. {
  290.   NINT ret_val = UIO_OK;
  291.   CTRIO_T ctrs[8];         /* Counters */    
  292.   TEXT   *sp;
  293.  
  294.   if (savebestf) {
  295.      ug_fileio("crcpltst", 1, 0, 0, 0);
  296.   } else {
  297.      PutStr("Test Set (T) or Training Set (L)?: ");
  298.      sp = GetStr( );
  299.      if (sp[0] == 'l' || sp[0] == 'L')
  300.         ug_fileio("crcpltrn", 1, 0, 0, 0);
  301.      else
  302.         ug_fileio("crcpltst", 1, 0, 0, 0);
  303.   }
  304.  
  305.   ug_winclr(W0);
  306.   ug_winclr(W1);
  307.   ug_circle(W0,on_color,0,(NINT)(0.35*W_Wid), (NINT)(0.50*W_Ht),
  308.             (NINT)(0.4*W_Ht),0);
  309.   ug_line(W0,on_color,0,(NINT)(0.75*W_Wid),0,(NINT)(0.75*W_Wid),W_Ht,0);
  310.  
  311.   if (savebestf) {
  312.      /* Read counters */
  313.      ug_ctrio(ctrs,0);
  314.   
  315.      sprintf(sbuf,"Logicon Projection Network (TM).  Lrn Cnt:%7ld",
  316.              ctrs[2]);
  317.      ug_puts(W1,on_color,0,6,4,sbuf,0);
  318.   }
  319.   count = 0;
  320.   good_count = 0;
  321.  
  322.   return(ret_val);
  323. }
  324.  
  325.  
  326. NINT UIO_Read(LayN, nPEs, Datap)
  327. NINT  LayN;
  328. NINT  nPEs;
  329. SREAL *Datap;
  330. {
  331.   NINT ret_val = UIO_OK;
  332.  
  333.   /* Since this is file IO, the data should already be in the buffer */
  334.   xin = Datap[0];
  335.   yin = Datap[1];
  336.   desval = -2.0;
  337.   return(ret_val);
  338.  
  339. }
  340.  
  341. NINT UIO_Write(LayN, nPEs, Datap)
  342. NINT  LayN;
  343. NINT  nPEs;
  344. SREAL *Datap;
  345. {
  346.   NINT  ret_val = UIO_OK;
  347.   SREAL outval;
  348.   NINT  x0, y0;
  349.  
  350.   outval = Datap[0];
  351.  
  352.   x0 = (xin+1.0) * W_Wid / 2;
  353.   y0 = (yin+0.5) * W_Ht;
  354.  
  355. #if 0
  356.   sprintf(sbuf,"%f %f %f %f\n  ", xin, yin, outval, desval);
  357.   PutStr(sbuf);
  358.   GetStr( );
  359. #endif
  360.  
  361.   ug_box(W0, outval>0.5?on_color:off_color,0,
  362.          x0-1,y0-1,x0+1,y0+1,0);
  363.  
  364.   if (desval >-1.5) {
  365.      count ++;
  366.      /* Assume sigmoid output */
  367.      if ((desval >0.5 && outval >0.5) ||
  368.          (desval <0.5 && outval <0.5))
  369.         good_count++;
  370.   }
  371.  
  372.   return(ret_val);
  373. }
  374.  
  375. NINT UIO_Write_Step(LayN, nPEs, Datap)
  376. NINT  LayN;
  377. NINT  nPEs;
  378. SREAL *Datap;
  379. {
  380.   NINT ret_val = UIO_OK;
  381.  
  382.   return(ret_val);
  383. }
  384.  
  385.  
  386. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  387. NINT  LayN;
  388. NINT  nPEs;
  389. SREAL *Datap;
  390. {
  391.   NINT ret_val = UIO_OK;
  392.  
  393.   /* Since this is file IO, the data should already be in the buffer */
  394.   desval = Datap[0];
  395.  
  396.   return(ret_val);
  397. }
  398.  
  399. NINT UIO_Recall_End()
  400. {
  401.   NINT ret_val = UIO_OK;
  402.  
  403.   ug_circle(W0,on_color,0,(NINT)(0.35*W_Wid), (NINT)(0.50*W_Ht),
  404.             (NINT)(0.4*W_Ht),0);
  405.   ug_line(W0,on_color,0,(NINT)(0.75*W_Wid),0,(NINT)(0.75*W_Wid),W_Ht,0);
  406.  
  407.   clssrate = 0.0;
  408.   if (count > 0) {
  409.      clssrate = ((float)good_count) / ((float)count);
  410.  
  411.      if (!savebestf) {
  412.         sprintf(sbuf,"Logicon Projection Network (TM). %5.2f%% Correct",
  413.                 100.0 * clssrate );
  414.         ug_puts(W1,on_color,0,15,4,sbuf,0);
  415.      }
  416.   }
  417.  
  418.   if (!savebestf) {
  419.      PutStr("Hit <Enter> to continue:");
  420.      GetStr( );
  421.   }
  422.  
  423.   return(ret_val);
  424. }
  425.  
  426. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  427. NINT  Instrument_id;
  428. NINT  nDataElems;
  429. SREAL *DataElemp;
  430. {
  431.   NINT ret_val = UIO_OK;
  432.  
  433.   return(ret_val);
  434. }
  435.  
  436. /* FUNCTION */
  437. NINT UIO_ObjFunc(eoeflag, DataElemp)
  438. NINT  eoeflag;
  439. SREAL *DataElemp;
  440. {
  441.   NINT ret_val = UIO_OK;
  442.  
  443.   if (eoeflag) {
  444.      savebestf = 0;   /* Clear save best flag */
  445.      /* Use classification rate as save best objective function */
  446.      /* Need to pass back 1-clssrate because assumption by NWorks
  447.         is the smaller the better */
  448.         
  449.      *DataElemp = 1.0-clssrate;
  450.   } else
  451.      savebestf = 1;   /* Tell recall we are in savebest mode */
  452.  
  453.   return(ret_val);
  454. }
  455.  
  456. NINT UIO_Rewind()
  457. {
  458.   NINT ret_val = UIO_OK;
  459.  
  460.   return(ret_val);
  461. }
  462.  
  463. NINT UIO_Explain(LayN, nPEs, Datap)
  464. NINT  LayN;
  465. NINT  nPEs;
  466. SREAL *Datap;
  467. {
  468.   NINT ret_val = UIO_OK;
  469.  
  470.   return(ret_val);
  471. }
  472.  
  473.  
  474.  
  475.